/**
 * 权限管理系统 - 通用工具函数
 * MyBatis高级应用作业 - 工具类
 */

// API基础URL
const API_BASE_URL = window.location.origin + window.location.pathname.replace(/\/[^/]*$/, '') + '/api';

/**
 * 通用API请求函数
 * @param {string} url - 请求URL
 * @param {Object} options - 请求选项
 * @returns {Promise} Promise对象
 */
function apiRequest(url, options = {}) {
    const defaultOptions = {
        method: 'GET',
        headers: {
            'Content-Type': 'application/json',
        },
    };

    const finalOptions = { ...defaultOptions, ...options };

    // 显示加载状态
    showLoading();

    return fetch(API_BASE_URL + url, finalOptions)
        .then(response => {
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            return response.json();
        })
        .then(data => {
            hideLoading();
            return data;
        })
        .catch(error => {
            hideLoading();
            console.error('API请求失败:', error);
            showMessage('请求失败: ' + error.message, 'error');
            throw error;
        });
}

/**
 * 显示加载状态
 */
function showLoading() {
    // 可以在这里添加全局加载指示器
    console.log('加载中...');
}

/**
 * 隐藏加载状态
 */
function hideLoading() {
    // 可以在这里隐藏全局加载指示器
    console.log('加载完成');
}

/**
 * 显示消息提示
 * @param {string} message - 消息内容
 * @param {string} type - 消息类型 (success, error, warning, info)
 */
function showMessage(message, type = 'info') {
    const messageDiv = document.createElement('div');
    messageDiv.className = `alert alert-${type}`;
    messageDiv.textContent = message;

    // 添加到页面顶部
    document.body.insertBefore(messageDiv, document.body.firstChild);

    // 3秒后自动移除
    setTimeout(() => {
        if (messageDiv.parentNode) {
            messageDiv.parentNode.removeChild(messageDiv);
        }
    }, 3000);
}

/**
 * 格式化日期时间
 * @param {string|Date} date - 日期字符串或Date对象
 * @returns {string} 格式化后的日期字符串
 */
function formatDateTime(date) {
    if (!date) return '';

    const d = new Date(date);
    return d.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit'
    });
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间(毫秒)
 * @returns {Function} 防抖后的函数
 */
function debounce(func, wait) {
    let timeout;
    return function executedFunction(...args) {
        const later = () => {
            clearTimeout(timeout);
            func(...args);
        };
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
    };
}

/**
 * 深度拷贝对象
 * @param {Object} obj - 要拷贝的对象
 * @returns {Object} 拷贝后的对象
 */
function deepClone(obj) {
    if (obj === null || typeof obj !== 'object') return obj;
    if (obj instanceof Date) return new Date(obj.getTime());
    if (obj instanceof Array) return obj.map(item => deepClone(item));
    if (obj instanceof Object) {
        const clonedObj = {};
        Object.keys(obj).forEach(key => {
            clonedObj[key] = deepClone(obj[key]);
        });
        return clonedObj;
    }
}

/**
 * 验证邮箱格式
 * @param {string} email - 邮箱地址
 * @returns {boolean} 是否有效
 */
function isValidEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}

/**
 * 验证手机号格式
 * @param {string} phone - 手机号码
 * @returns {boolean} 是否有效
 */
function isValidPhone(phone) {
    const phoneRegex = /^1[3-9]\d{9}$/;
    return phoneRegex.test(phone);
}

/**
 * 生成随机ID
 * @param {number} length - ID长度
 * @returns {string} 随机ID
 */
function generateId(length = 8) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
        result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
}

/**
 * 获取URL参数
 * @param {string} name - 参数名
 * @returns {string|null} 参数值
 */
function getUrlParam(name) {
    const urlParams = new URLSearchParams(window.location.search);
    return urlParams.get(name);
}

/**
 * 设置URL参数
 * @param {string} name - 参数名
 * @param {string} value - 参数值
 */
function setUrlParam(name, value) {
    const url = new URL(window.location);
    url.searchParams.set(name, value);
    window.history.replaceState({}, '', url);
}

/**
 * 移除URL参数
 * @param {string} name - 参数名
 */
function removeUrlParam(name) {
    const url = new URL(window.location);
    url.searchParams.delete(name);
    window.history.replaceState({}, '', url);
}

/**
 * 本地存储工具
 */
const storage = {
    /**
     * 设置存储项
     * @param {string} key - 键名
     * @param {any} value - 值
     */
    set(key, value) {
        try {
            localStorage.setItem(key, JSON.stringify(value));
        } catch (error) {
            console.error('本地存储设置失败:', error);
        }
    },

    /**
     * 获取存储项
     * @param {string} key - 键名
     * @param {any} defaultValue - 默认值
     * @returns {any} 存储的值
     */
    get(key, defaultValue = null) {
        try {
            const item = localStorage.getItem(key);
            return item ? JSON.parse(item) : defaultValue;
        } catch (error) {
            console.error('本地存储获取失败:', error);
            return defaultValue;
        }
    },

    /**
     * 移除存储项
     * @param {string} key - 键名
     */
    remove(key) {
        try {
            localStorage.removeItem(key);
        } catch (error) {
            console.error('本地存储移除失败:', error);
        }
    },

    /**
     * 清空所有存储
     */
    clear() {
        try {
            localStorage.clear();
        } catch (error) {
            console.error('本地存储清空失败:', error);
        }
    }
};

/**
 * 导出工具函数
 */
window.utils = {
    apiRequest,
    showMessage,
    formatDateTime,
    debounce,
    deepClone,
    isValidEmail,
    isValidPhone,
    generateId,
    getUrlParam,
    setUrlParam,
    removeUrlParam,
    storage
};

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    console.log('权限管理系统已加载');

    // 可以在这里添加全局初始化逻辑
    initializeApp();
});

/**
 * 应用初始化
 */
function initializeApp() {
    // 添加全局错误处理
    window.addEventListener('error', function(event) {
        console.error('全局错误:', event.error);
        showMessage('发生未知错误，请查看控制台', 'error');
    });

    // 添加未处理的Promise拒绝处理
    window.addEventListener('unhandledrejection', function(event) {
        console.error('未处理的Promise拒绝:', event.reason);
        showMessage('请求处理失败', 'error');
        event.preventDefault();
    });

    // 可以在这里添加其他初始化逻辑
    console.log('应用初始化完成');
}

/**
 * 数据导出工具
 */
const exportUtils = {
    /**
     * 导出为JSON文件
     * @param {Object} data - 要导出的数据
     * @param {string} filename - 文件名
     */
    exportToJson(data, filename = 'data.json') {
        const dataStr = JSON.stringify(data, null, 2);
        this.downloadFile(dataStr, filename, 'application/json');
    },

    /**
     * 导出为CSV文件
     * @param {Array} data - 要导出的数据数组
     * @param {string} filename - 文件名
     */
    exportToCsv(data, filename = 'data.csv') {
        if (!data || data.length === 0) {
            showMessage('没有数据可导出', 'warning');
            return;
        }

        const headers = Object.keys(data[0]);
        const csvContent = [
            headers.join(','),
            ...data.map(row =>
                headers.map(header =>
                    `"${String(row[header] || '').replace(/"/g, '""')}"`
                ).join(',')
            )
        ].join('\n');

        this.downloadFile(csvContent, filename, 'text/csv');
    },

    /**
     * 下载文件
     * @param {string} content - 文件内容
     * @param {string} filename - 文件名
     * @param {string} contentType - 内容类型
     */
    downloadFile(content, filename, contentType) {
        const blob = new Blob([content], { type: contentType });
        const url = URL.createObjectURL(blob);
        const link = document.createElement('a');
        link.href = url;
        link.download = filename;
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        URL.revokeObjectURL(url);
    }
};

// 将导出工具添加到全局工具中
window.utils.export = exportUtils;